PC for Alla 2005 May/PC för Alla 0505.iso/fullversioner/realsoft3d/data1.cab/Scripting/scripts/js/real/objects/r3numesh.js

JavaScript | 2005-04-04 | 25.8 KB | 850 lines

// JavaScript wrapper for r3numesh.h
// Auto generated file, do not modify by hand
// Copyright ⌐ 2004, Realsoft Graphics Oy

var R3_NUMESH_H = 1;
include("real/objects/r3level.js")


var R3CLID_NUMESH = 128;




// Description: Set control point.
// Returns: Boolean, true if point was succesfully set
// p1: Integer, index of the control point to be set
// p3: r3Vect4, value for the control point

R3NUMM_SETPOINT4 = 128000;

function mR3NUMM_SETPOINT4(p1, p3) {
  return   DoA2(this.r3obj, 128000, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}


R3NUMCM_REGISTERCONSTRUCTOR = 128001;

function mR3NUMCM_REGISTERCONSTRUCTOR() {
  DoA(this.r3obj, 128001, 0, R3TID_INTEGER, 0);
}


R3NUMM_GETCONSTRUCTION = 128002;

function mR3NUMM_GETCONSTRUCTION() {
  DoA(this.r3obj, 128002, 0, R3TID_INTEGER, 0);
}


R3NUMM_RELEASECONSTRUCTION = 128003;

function mR3NUMM_RELEASECONSTRUCTION() {
  DoA(this.r3obj, 128003, 0, R3TID_INTEGER, 0);
}

// Description: Concatenates given mesh. The order and direction in which the concatenation is performed is
//      determined from the distances between the edges of surfaces.
// Returns: Boolean, TRUE if concatenation succeeded.
// p3: Object[], array of object addresses

R3NUMM_CONCATENATE = 128005;

function mR3NUMM_CONCATENATE(p3) {
  return   DoA(this.r3obj, 128005, p3, R3TID_OBJECT, R3TNF_ARRAY);
}

// Description: Deletes construction history objects
// Returns: Integer, number of construction objects deleted

R3NUMM_DELETECONSTRUCTIONHIS = 128006;

function mR3NUMM_DELETECONSTRUCTIONHIS() {
  return   DoA(this.r3obj, 128006, 0, R3TID_INTEGER, 0);
}

// Description: Reparametrize mesh to given resolution. If the resolution is increased, the shape of the
//      mesh remains the same.
// Returns: Boolean, NULL if failed (not enough memory)
// p1: Integer, new u-resolution.
// p3: Integer, new v-resolution

R3NUMM_REPARAM = 128007;

function mR3NUMM_REPARAM(p1, p3) {
  return   DoA2(this.r3obj, 128007, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}

// Description: Deletes a curve from the mesh
// Returns: Object, TRUE if successful
// p3: Integer, u-curve to delete, 0 ... u-resolution-1.

R3NUMM_DELETECURVEU = 128008;

function mR3NUMM_DELETECURVEU(p3) {
  return   DoA(this.r3obj, 128008, p3, R3TID_INTEGER, 0);
}

// Description: Deletes a curve from the mesh
// Returns: Object, TRUE if successful
// p3: Integer, v-curve to delete, 0 ... v-resolution-1.

R3NUMM_DELETECURVEV = 128009;

function mR3NUMM_DELETECURVEV(p3) {
  return   DoA(this.r3obj, 128009, p3, R3TID_INTEGER, 0);
}

// Description: Update knot sequences

R3NUMM_UPDATEPARAMETRIZATION = 128010;

function mR3NUMM_UPDATEPARAMETRIZATION() {
  DoA(this.r3obj, 128010, 0, R3TID_INTEGER, 0);
}

// Description: Create a trimmed planar surface from given points
// p1: Integer, number of points
// p2: Integer, order
// p3: r3Vect, control points for the trim curve

R3NUMCM_CREATETRIMMEDPOLYGON = 128011;

function mR3NUMCM_CREATETRIMMEDPOLYGON(p1, p2, p3) {
  DoA3(this.r3obj, 128011, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Swap direction of the mesh
// p1: Boolean, if true, u is reversed
// p3: Boolean, if true, v is reversed

R3NUMM_SWAPDIRECTION = 128012;

function mR3NUMM_SWAPDIRECTION(p1, p3) {
  DoA2(this.r3obj, 128012, p1, R3TID_BOOLEAN, 0, p3, R3TID_BOOLEAN, 0);
}

// Description: Convert given object to bezier form of nurbs mesh
// Returns: Object, created nurbs mesh
// p1: Integer, density, number of patches is computed as p1 * complexity
// p2: Integer, density in v direction
// p3: Object, object to be converted

R3NUMCM_CREATEBEZIERMESH = 128013;

function mR3NUMCM_CREATEBEZIERMESH(p1, p2, p3) {
  return R3ToJS(  DoA3(this.r3obj, 128013, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_OBJECT, 0));
}

// Description: Translate the weights of the selected control points
// p3: Number, weight translation

R3NUMM_CHANGEWEIGHTS = 128014;

function mR3NUMM_CHANGEWEIGHTS(p3) {
  DoA(this.r3obj, 128014, p3, R3TID_FLOAT, 0);
}

// Description: Set UV coordinates for the selected points
// Returns: Boolean, true if succeeded

R3NUMM_SETUV = 128015;

function mR3NUMM_SETUV() {
  return   DoA(this.r3obj, 128015, 0, R3TID_INTEGER, 0);
}

// Description: Get UV coordinates of the given point
// Returns: Boolean, true if succeeded
// p1: r3Vect
// p3: Integer, index of the point

R3NUMM_GETUV = 128016;

function mR3NUMM_GETUV(p1, p3) {
  return   DoA2(this.r3obj, 128016, p1, R3TID_VECTOR, 0, p3, R3TID_INTEGER, 0);
}

// Description: Defines texture uv coordinates for the mesh.

R3NUMM_DEFINETEXTUREUV = 128017;

function mR3NUMM_DEFINETEXTUREUV() {
  DoA(this.r3obj, 128017, 0, R3TID_INTEGER, 0);
}

// Description: Make the surface 'sharp' at given direction and parameter value
// p1: Integer, R3NUMD_U/R3NUMD_V

R3NUMM_SHARPEN = 128018;

function mR3NUMM_SHARPEN(p1) {
  DoA2(this.r3obj, 128018, p1, R3TID_INTEGER, 0, 0, R3TID_INTEGER, 0);
}

// Description: These methods cut off the head/tail of the surface at the given parameter value/direction.
// Returns: Boolean, true if succeeded.
// p1: Integer, direction

R3NUMM_CUTTAIL = 128020;

function mR3NUMM_CUTTAIL(p1) {
  return   DoA2(this.r3obj, 128020, p1, R3TID_INTEGER, 0, 0, R3TID_INTEGER, 0);
}

// Description: Insert a new isop. curve to a mesh
// Returns: Boolean, true if succeeded
// p1: Integer, direcction
// p3: r3Vect, uv

R3NUMM_INSERTKNOT = 128021;

function mR3NUMM_INSERTKNOT(p1, p3) {
  return   DoA2(this.r3obj, 128021, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR, 0);
}

// Description: Optimized update method. Don't call this directly.

R3NUMM_DOUPDATE = 128022;

function mR3NUMM_DOUPDATE() {
  DoA(this.r3obj, 128022, 0, R3TID_INTEGER, 0);
}

// Description: Set start point (u=0/v=0) for a closed mesh.
// Returns: Boolean, true if succeeded. Returns false if the mesh is not closed int the given
//      direction.

R3NUMM_SETSTART = 128023;

function mR3NUMM_SETSTART() {
  return   DoA(this.r3obj, 128023, 0, R3TID_INTEGER, 0);
}

// Description: Open the mesh in the given direction. The shape of the mesh remains the
//      same.
// Returns: Boolean, true if succeeded.

R3NUMM_OPEN = 128024;

function mR3NUMM_OPEN() {
  return   DoA(this.r3obj, 128024, 0, R3TID_INTEGER, 0);
}

// Description: Transpose the mesh i.e. swap the u and v directions.
// Returns: Boolean, true if succeeded, FALSE indicates not enough memory.

R3NUMM_SWAPUV = 128025;

function mR3NUMM_SWAPUV() {
  return   DoA(this.r3obj, 128025, 0, R3TID_INTEGER, 0);
}

// Description: Degree elevation. The shape of the mesh remains unchanged.
// Returns: Boolean, true if succeeded

R3NUMM_ELEVATEDEGREE = 128026;

function mR3NUMM_ELEVATEDEGREE() {
  return   DoA(this.r3obj, 128026, 0, R3TID_INTEGER, 0);
}


R3NUMM_ENUMVARATTRSCALLBACK = 128027;

function mR3NUMM_ENUMVARATTRSCALLBACK() {
  DoA(this.r3obj, 128027, 0, R3TID_INTEGER, 0);
}

// Description: Get control points of given row/column.
// Returns: Boolean, true if given row/colum exists.
// p1: Integer, index of the row or column

R3NUMM_GETCTRLCURVE = 128028;

function mR3NUMM_GETCTRLCURVE(p1) {
  return   DoA2(this.r3obj, 128028, p1, R3TID_INTEGER, 0, 0, R3TID_INTEGER, 0);
}


R3NUMM_CONCATEXACT = 128029;

function mR3NUMM_CONCATEXACT() {
  DoA(this.r3obj, 128029, 0, R3TID_INTEGER, 0);
}

// Description: Fetch control point
// Returns: Boolean, true if succeeded
// p1: Integer, index of the point to be fetched
// p3: r3Vect4, buffer

R3NUMM_GETPOINT4 = 128034;

function mR3NUMM_GETPOINT4(p1, p3) {
  return   DoA2(this.r3obj, 128034, p1, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Set knot by index
// Returns: Boolean, true if succeeded
// p1: Integer, index of the knot
// p2: Integer, direction R3NUMD_U or rR3NUMD_V
// p3: Number, knot value

R3NUMM_SETKNOT = 128035;

function mR3NUMM_SETKNOT(p1, p2, p3) {
  return   DoA3(this.r3obj, 128035, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Fetch knot by index
// Returns: Boolean, true if succeeded
// p1: Integer, index of the knot
// p2: Integer, direction R3NUMD_U or rR3NUMD_V
// p3: Number, buffer for the knot value to be fetched

R3NUMM_GETKNOT = 128036;

function mR3NUMM_GETKNOT(p1, p2, p3) {
  return   DoA3(this.r3obj, 128036, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_FLOAT, 0);
}

// Description: Low level set point method. The point is given in object space.    * The method
//      doesn't generate R3MM_CHANGED nor call R3TTM_CHANGENIMATEDTAG.
// Returns: Boolean, true if succeeded
// p1: Integer, index_u
// p2: Integer, index_v
// p3: r3Vect4, point

R3NUMM_SETPOINTLOCAL = 128037;

function mR3NUMM_SETPOINTLOCAL(p1, p2, p3) {
  return   DoA3(this.r3obj, 128037, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Get point in object space
// Returns: Boolean, true if succeeded
// p1: Integer, index_u
// p2: Integer, index_v
// p3: r3Vect4, point

R3NUMM_GETPOINTLOCAL = 128038;

function mR3NUMM_GETPOINTLOCAL(p1, p2, p3) {
  return   DoA3(this.r3obj, 128038, p1, R3TID_INTEGER, 0, p2, R3TID_INTEGER, 0, p3, R3TID_VECTOR4, 0);
}

// Description: Get wrap state of a point channel
// Returns: Boolean, true if channel found
// p1: Integer, channel id
// p3: Integer[], wrap state

R3NUMM_GETWRAPV = 128040;

function mR3NUMM_GETWRAPV(p1, p3) {
  return   DoA2(this.r3obj, 128040, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, R3TNF_ARRAY);
}

// Description: Set wrap state of a point channel
// Returns: Boolean, true if channel found
// p1: Integer, channel id
// p3: Integer, wrap state

R3NUMM_SETWRAPV = 128042;

function mR3NUMM_SETWRAPV(p1, p3) {
  return   DoA2(this.r3obj, 128042, p1, R3TID_INTEGER, 0, p3, R3TID_INTEGER, 0);
}




R3NUMA_CountU = 128501;
function SetR3NUMA_CountU(value) {
  R3Set(this.r3obj, R3NUMA_CountU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_CountU() {
  return R3Get(this.r3obj, R3NUMA_CountU, R3TID_INTEGER, 0);
}

R3NUMA_CountV = 128502;
function SetR3NUMA_CountV(value) {
  R3Set(this.r3obj, R3NUMA_CountV, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_CountV() {
  return R3Get(this.r3obj, R3NUMA_CountV, R3TID_INTEGER, 0);
}

R3NUMA_OrderU = 128503;
function SetR3NUMA_OrderU(value) {
  R3Set(this.r3obj, R3NUMA_OrderU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_OrderU() {
  return R3Get(this.r3obj, R3NUMA_OrderU, R3TID_INTEGER, 0);
}

R3NUMA_OrderV = 128504;
function SetR3NUMA_OrderV(value) {
  R3Set(this.r3obj, R3NUMA_OrderV, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_OrderV() {
  return R3Get(this.r3obj, R3NUMA_OrderV, R3TID_INTEGER, 0);
}

R3NUMA_KnotsU = 128505;
function SetR3NUMA_KnotsU(value) {
  R3Set(this.r3obj, R3NUMA_KnotsU, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_KnotsU() {
  return R3Get(this.r3obj, R3NUMA_KnotsU, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_KnotsV = 128506;
function SetR3NUMA_KnotsV(value) {
  R3Set(this.r3obj, R3NUMA_KnotsV, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_KnotsV() {
  return R3Get(this.r3obj, R3NUMA_KnotsV, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_Points = 128507;
function SetR3NUMA_Points(value) {
  R3Set(this.r3obj, R3NUMA_Points, value, R3TID_OBJECT, 0);
}

function GetR3NUMA_Points() {
  return R3ToJS(R3Get(this.r3obj, R3NUMA_Points, R3TID_OBJECT, 0));
}

R3NUMA_Points3 = 128508;
function SetR3NUMA_Points3(value) {
  R3Set(this.r3obj, R3NUMA_Points3, value, R3TID_VECTOR, 0);
}

R3NUMA_KnotCountU = 128509;
function GetR3NUMA_KnotCountU() {
  return R3Get(this.r3obj, R3NUMA_KnotCountU, R3TID_INTEGER, 0);
}

R3NUMA_KnotCountV = 128510;
function GetR3NUMA_KnotCountV() {
  return R3Get(this.r3obj, R3NUMA_KnotCountV, R3TID_INTEGER, 0);
}

R3NUMA_Constructor = 128511;
function SetR3NUMA_Constructor(value) {
  R3Set(this.r3obj, R3NUMA_Constructor, value, R3TID_STRING, 0);
}

function GetR3NUMA_Constructor() {
  return R3Get(this.r3obj, R3NUMA_Constructor, R3TID_STRING, 0);
}

R3NUMA_ClosedU = 128512;
function SetR3NUMA_ClosedU(value) {
  R3Set(this.r3obj, R3NUMA_ClosedU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_ClosedU() {
  return R3Get(this.r3obj, R3NUMA_ClosedU, R3TID_INTEGER, 0);
}

R3NUMA_ClosedV = 128513;
function SetR3NUMA_ClosedV(value) {
  R3Set(this.r3obj, R3NUMA_ClosedV, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_ClosedV() {
  return R3Get(this.r3obj, R3NUMA_ClosedV, R3TID_INTEGER, 0);
}

var R3NUMA_EndCondU = 128514; // Integer
var R3NUMA_EndCondV = 128515; // Integer
R3NUMA_InParentsParamSpace = 128516;
function SetR3NUMA_InParentsParamSpace(value) {
  R3Set(this.r3obj, R3NUMA_InParentsParamSpace, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_InParentsParamSpace() {
  return R3Get(this.r3obj, R3NUMA_InParentsParamSpace, R3TID_INTEGER, 0);
}

R3NUMA_TrimInvert = 128517;
function SetR3NUMA_TrimInvert(value) {
  R3Set(this.r3obj, R3NUMA_TrimInvert, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_TrimInvert() {
  return R3Get(this.r3obj, R3NUMA_TrimInvert, R3TID_INTEGER, 0);
}

R3NUMA_SelectResolution = 128523;
function SetR3NUMA_SelectResolution(value) {
  R3Set(this.r3obj, R3NUMA_SelectResolution, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_SelectResolution() {
  return R3Get(this.r3obj, R3NUMA_SelectResolution, R3TID_INTEGER, 0);
}

R3NUMA_RemapUV = 128524;
function SetR3NUMA_RemapUV(value) {
  R3Set(this.r3obj, R3NUMA_RemapUV, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_RemapUV() {
  return R3Get(this.r3obj, R3NUMA_RemapUV, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_Invisible = 128525;
function SetR3NUMA_Invisible(value) {
  R3Set(this.r3obj, R3NUMA_Invisible, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_Invisible() {
  return R3Get(this.r3obj, R3NUMA_Invisible, R3TID_INTEGER, 0);
}

R3NUMA_ParametrizationU = 128526;
function SetR3NUMA_ParametrizationU(value) {
  R3Set(this.r3obj, R3NUMA_ParametrizationU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_ParametrizationU() {
  return R3Get(this.r3obj, R3NUMA_ParametrizationU, R3TID_INTEGER, 0);
}

R3NUMA_ParametrizationV = 128527;
function SetR3NUMA_ParametrizationV(value) {
  R3Set(this.r3obj, R3NUMA_ParametrizationV, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_ParametrizationV() {
  return R3Get(this.r3obj, R3NUMA_ParametrizationV, R3TID_INTEGER, 0);
}

R3NUMA_TrimBoolean = 128528;
function SetR3NUMA_TrimBoolean(value) {
  R3Set(this.r3obj, R3NUMA_TrimBoolean, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_TrimBoolean() {
  return R3Get(this.r3obj, R3NUMA_TrimBoolean, R3TID_INTEGER, 0);
}

R3NUMA_Quality = 128529;
function SetR3NUMA_Quality(value) {
  R3Set(this.r3obj, R3NUMA_Quality, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_Quality() {
  return R3Get(this.r3obj, R3NUMA_Quality, R3TID_INTEGER, 0);
}

R3NUMA_UVSize = 128530;
function GetR3NUMA_UVSize() {
  return R3Get(this.r3obj, R3NUMA_UVSize, R3TID_INTEGER, 0);
}

R3NUMA_PointwiseColor = 128531;
function SetR3NUMA_PointwiseColor(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseColor, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseColor() {
  return R3Get(this.r3obj, R3NUMA_PointwiseColor, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseTransparency = 128532;
function SetR3NUMA_PointwiseTransparency(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseTransparency, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseTransparency() {
  return R3Get(this.r3obj, R3NUMA_PointwiseTransparency, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseReflection = 128533;
function SetR3NUMA_PointwiseReflection(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseReflection, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseReflection() {
  return R3Get(this.r3obj, R3NUMA_PointwiseReflection, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseAlpha = 128534;
function SetR3NUMA_PointwiseAlpha(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseAlpha, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseAlpha() {
  return R3Get(this.r3obj, R3NUMA_PointwiseAlpha, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseFade = 128535;
function SetR3NUMA_PointwiseFade(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseFade, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseFade() {
  return R3Get(this.r3obj, R3NUMA_PointwiseFade, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseIllumination = 128536;
function SetR3NUMA_PointwiseIllumination(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseIllumination, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseIllumination() {
  return R3Get(this.r3obj, R3NUMA_PointwiseIllumination, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseMatSpaceCoor = 128537;
function SetR3NUMA_PointwiseMatSpaceCoor(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseMatSpaceCoor, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseMatSpaceCoor() {
  return R3Get(this.r3obj, R3NUMA_PointwiseMatSpaceCoor, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseOpticalThick = 128538;
function SetR3NUMA_PointwiseOpticalThick(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseOpticalThick, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseOpticalThick() {
  return R3Get(this.r3obj, R3NUMA_PointwiseOpticalThick, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseScope = 128539;
function SetR3NUMA_PointwiseScope(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseScope, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseScope() {
  return R3Get(this.r3obj, R3NUMA_PointwiseScope, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseVolumeSampli = 128540;
function SetR3NUMA_PointwiseVolumeSampli(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseVolumeSampli, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseVolumeSampli() {
  return R3Get(this.r3obj, R3NUMA_PointwiseVolumeSampli, R3TID_FLOAT, R3TNF_ARRAY);
}

R3NUMA_PointwiseUVCoords = 128541;
function SetR3NUMA_PointwiseUVCoords(value) {
  R3Set(this.r3obj, R3NUMA_PointwiseUVCoords, value, R3TID_FLOAT, R3TNF_ARRAY);
}

function GetR3NUMA_PointwiseUVCoords() {
  return R3Get(this.r3obj, R3NUMA_PointwiseUVCoords, R3TID_FLOAT, R3TNF_ARRAY);
}

var R3NUMA_PointwiseChannel = 128543; // Integer
var R3NUMA_PointwiseID = 128544; // Integer
var R3NUMA_PointwiseName = 128545; // String
var R3NUMA_PointwiseData = 128546; // Object
R3NUMA_MaxDisplacement = 128547;
function SetR3NUMA_MaxDisplacement(value) {
  R3Set(this.r3obj, R3NUMA_MaxDisplacement, value, R3TID_FLOAT, 0);
}

function GetR3NUMA_MaxDisplacement() {
  return R3Get(this.r3obj, R3NUMA_MaxDisplacement, R3TID_FLOAT, 0);
}

R3NUMA_RotateCountU = 1224865468;
function SetR3NUMA_RotateCountU(value) {
  R3Set(this.r3obj, R3NUMA_RotateCountU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_RotateCountU() {
  return R3Get(this.r3obj, R3NUMA_RotateCountU, R3TID_INTEGER, 0);
}

R3NUMA_RotateOrderU = 1224865469;
function SetR3NUMA_RotateOrderU(value) {
  R3Set(this.r3obj, R3NUMA_RotateOrderU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_RotateOrderU() {
  return R3Get(this.r3obj, R3NUMA_RotateOrderU, R3TID_INTEGER, 0);
}

R3NUMA_CrossectFlags = 1224865470;
function SetR3NUMA_CrossectFlags(value) {
  R3Set(this.r3obj, R3NUMA_CrossectFlags, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_CrossectFlags() {
  return R3Get(this.r3obj, R3NUMA_CrossectFlags, R3TID_INTEGER, 0);
}

R3NUMA_CrossectCountU = 1224865471;
function SetR3NUMA_CrossectCountU(value) {
  R3Set(this.r3obj, R3NUMA_CrossectCountU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_CrossectCountU() {
  return R3Get(this.r3obj, R3NUMA_CrossectCountU, R3TID_INTEGER, 0);
}

R3NUMA_CrossectOrderU = 1224865472;
function SetR3NUMA_CrossectOrderU(value) {
  R3Set(this.r3obj, R3NUMA_CrossectOrderU, value, R3TID_INTEGER, 0);
}

function GetR3NUMA_CrossectOrderU() {
  return R3Get(this.r3obj, R3NUMA_CrossectOrderU, R3TID_INTEGER, 0);
}

var R3NUMF_CROSSECTOVERRIDE_COUNT = 1;
var R3NUMF_CROSSECTOVERRIDE_ORDER = 2;
var R3NUMEB_OR = 0;
var R3NUMEB_AND = 1;
var R3NUMEB_XOR = 2;
var R3NUMEMAX_CONSTRHOOKS = 50;
var R3NUMEHT_POINT = 1;
var R3NUMEHT_UCURVE = 2;
var R3NUMEHT_VCURVE = 3;
var R3NUMESR_POINT = 0;
var R3NUMESR_CURVE = 1;
var R3NUMD_U = 0;
var R3NUMD_V = 1;
var R3NUMD_UV = 2;


function r3Numesh () {
   this.base = r3God;
   if(arguments.length) {
      this.base(R3CLID_NUMESH, arguments);
   }
   // Methods
   this.SETPOINT4=mR3NUMM_SETPOINT4;
   this.REGISTERCONSTRUCTOR=mR3NUMCM_REGISTERCONSTRUCTOR;
   this.GETCONSTRUCTION=mR3NUMM_GETCONSTRUCTION;
   this.RELEASECONSTRUCTION=mR3NUMM_RELEASECONSTRUCTION;
   this.CONCATENATE=mR3NUMM_CONCATENATE;
   this.DELETECONSTRUCTIONHIS=mR3NUMM_DELETECONSTRUCTIONHIS;
   this.REPARAM=mR3NUMM_REPARAM;
   this.DELETECURVEU=mR3NUMM_DELETECURVEU;
   this.DELETECURVEV=mR3NUMM_DELETECURVEV;
   this.UPDATEPARAMETRIZATION=mR3NUMM_UPDATEPARAMETRIZATION;
   this.CREATETRIMMEDPOLYGON=mR3NUMCM_CREATETRIMMEDPOLYGON;
   this.SWAPDIRECTION=mR3NUMM_SWAPDIRECTION;
   this.CREATEBEZIERMESH=mR3NUMCM_CREATEBEZIERMESH;
   this.CHANGEWEIGHTS=mR3NUMM_CHANGEWEIGHTS;
   this.SETUV=mR3NUMM_SETUV;
   this.GETUV=mR3NUMM_GETUV;
   this.DEFINETEXTUREUV=mR3NUMM_DEFINETEXTUREUV;
   this.SHARPEN=mR3NUMM_SHARPEN;
   this.CUTTAIL=mR3NUMM_CUTTAIL;
   this.INSERTKNOT=mR3NUMM_INSERTKNOT;
   this.DOUPDATE=mR3NUMM_DOUPDATE;
   this.SETSTART=mR3NUMM_SETSTART;
   this.OPEN=mR3NUMM_OPEN;
   this.SWAPUV=mR3NUMM_SWAPUV;
   this.ELEVATEDEGREE=mR3NUMM_ELEVATEDEGREE;
   this.ENUMVARATTRSCALLBACK=mR3NUMM_ENUMVARATTRSCALLBACK;
   this.GETCTRLCURVE=mR3NUMM_GETCTRLCURVE;
   this.CONCATEXACT=mR3NUMM_CONCATEXACT;
   this.GETPOINT4=mR3NUMM_GETPOINT4;
   this.SETKNOT=mR3NUMM_SETKNOT;
   this.GETKNOT=mR3NUMM_GETKNOT;
   this.SETPOINTLOCAL=mR3NUMM_SETPOINTLOCAL;
   this.GETPOINTLOCAL=mR3NUMM_GETPOINTLOCAL;
   this.GETWRAPV=mR3NUMM_GETWRAPV;
   this.SETWRAPV=mR3NUMM_SETWRAPV;

   // Attributes
   this.GetCountU=GetR3NUMA_CountU;
   this.SetCountU=SetR3NUMA_CountU;
   this.GetCountV=GetR3NUMA_CountV;
   this.SetCountV=SetR3NUMA_CountV;
   this.GetOrderU=GetR3NUMA_OrderU;
   this.SetOrderU=SetR3NUMA_OrderU;
   this.GetOrderV=GetR3NUMA_OrderV;
   this.SetOrderV=SetR3NUMA_OrderV;
   this.GetKnotsU=GetR3NUMA_KnotsU;
   this.SetKnotsU=SetR3NUMA_KnotsU;
   this.GetKnotsV=GetR3NUMA_KnotsV;
   this.SetKnotsV=SetR3NUMA_KnotsV;
   this.GetPoints=GetR3NUMA_Points;
   this.SetPoints=SetR3NUMA_Points;
   this.SetPoints3=SetR3NUMA_Points3;
   this.GetKnotCountU=GetR3NUMA_KnotCountU;
   this.GetKnotCountV=GetR3NUMA_KnotCountV;
   this.GetConstructor=GetR3NUMA_Constructor;
   this.SetConstructor=SetR3NUMA_Constructor;
   this.GetClosedU=GetR3NUMA_ClosedU;
   this.SetClosedU=SetR3NUMA_ClosedU;
   this.GetClosedV=GetR3NUMA_ClosedV;
   this.SetClosedV=SetR3NUMA_ClosedV;
   this.GetInParentsParamSpace=GetR3NUMA_InParentsParamSpace;
   this.SetInParentsParamSpace=SetR3NUMA_InParentsParamSpace;
   this.GetTrimInvert=GetR3NUMA_TrimInvert;
   this.SetTrimInvert=SetR3NUMA_TrimInvert;
   this.GetSelectResolution=GetR3NUMA_SelectResolution;
   this.SetSelectResolution=SetR3NUMA_SelectResolution;
   this.GetRemapUV=GetR3NUMA_RemapUV;
   this.SetRemapUV=SetR3NUMA_RemapUV;
   this.GetInvisible=GetR3NUMA_Invisible;
   this.SetInvisible=SetR3NUMA_Invisible;
   this.GetParametrizationU=GetR3NUMA_ParametrizationU;
   this.SetParametrizationU=SetR3NUMA_ParametrizationU;
   this.GetParametrizationV=GetR3NUMA_ParametrizationV;
   this.SetParametrizationV=SetR3NUMA_ParametrizationV;
   this.GetTrimBoolean=GetR3NUMA_TrimBoolean;
   this.SetTrimBoolean=SetR3NUMA_TrimBoolean;
   this.GetQuality=GetR3NUMA_Quality;
   this.SetQuality=SetR3NUMA_Quality;
   this.GetUVSize=GetR3NUMA_UVSize;
   this.GetPointwiseColor=GetR3NUMA_PointwiseColor;
   this.SetPointwiseColor=SetR3NUMA_PointwiseColor;
   this.GetPointwiseTransparency=GetR3NUMA_PointwiseTransparency;
   this.SetPointwiseTransparency=SetR3NUMA_PointwiseTransparency;
   this.GetPointwiseReflection=GetR3NUMA_PointwiseReflection;
   this.SetPointwiseReflection=SetR3NUMA_PointwiseReflection;
   this.GetPointwiseAlpha=GetR3NUMA_PointwiseAlpha;
   this.SetPointwiseAlpha=SetR3NUMA_PointwiseAlpha;
   this.GetPointwiseFade=GetR3NUMA_PointwiseFade;
   this.SetPointwiseFade=SetR3NUMA_PointwiseFade;
   this.GetPointwiseIllumination=GetR3NUMA_PointwiseIllumination;
   this.SetPointwiseIllumination=SetR3NUMA_PointwiseIllumination;
   this.GetPointwiseMatSpaceCoor=GetR3NUMA_PointwiseMatSpaceCoor;
   this.SetPointwiseMatSpaceCoor=SetR3NUMA_PointwiseMatSpaceCoor;
   this.GetPointwiseOpticalThick=GetR3NUMA_PointwiseOpticalThick;
   this.SetPointwiseOpticalThick=SetR3NUMA_PointwiseOpticalThick;
   this.GetPointwiseScope=GetR3NUMA_PointwiseScope;
   this.SetPointwiseScope=SetR3NUMA_PointwiseScope;
   this.GetPointwiseVolumeSampli=GetR3NUMA_PointwiseVolumeSampli;
   this.SetPointwiseVolumeSampli=SetR3NUMA_PointwiseVolumeSampli;
   this.GetPointwiseUVCoords=GetR3NUMA_PointwiseUVCoords;
   this.SetPointwiseUVCoords=SetR3NUMA_PointwiseUVCoords;
   this.GetMaxDisplacement=GetR3NUMA_MaxDisplacement;
   this.SetMaxDisplacement=SetR3NUMA_MaxDisplacement;
   this.GetRotateCountU=GetR3NUMA_RotateCountU;
   this.SetRotateCountU=SetR3NUMA_RotateCountU;
   this.GetRotateOrderU=GetR3NUMA_RotateOrderU;
   this.SetRotateOrderU=SetR3NUMA_RotateOrderU;
   this.GetCrossectFlags=GetR3NUMA_CrossectFlags;
   this.SetCrossectFlags=SetR3NUMA_CrossectFlags;
   this.GetCrossectCountU=GetR3NUMA_CrossectCountU;
   this.SetCrossectCountU=SetR3NUMA_CrossectCountU;
   this.GetCrossectOrderU=GetR3NUMA_CrossectOrderU;
   this.SetCrossectOrderU=SetR3NUMA_CrossectOrderU;
}

r3Numesh.prototype=new r3Level;
// r3numesh.h_H